home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacApp Release 10 / MacApp Release 10 - HD Ready / Libraries / Core / Sources / UDependencies.cp < prev    next >
Encoding:
Text File  |  1996-04-03  |  26.3 KB  |  815 lines  |  [TEXT/MPS ]
  1. //----------------------------------------------------------------------------------------
  2. // UDependencies.cp
  3. // Copyright © 1988-96 by Apple Computer, Inc. All rights reserved.
  4. //----------------------------------------------------------------------------------------
  5.  
  6. #ifndef __UDEPENDENCIES__
  7. #include "UDependencies.h"
  8. #endif
  9.  
  10. // MacApp
  11.  
  12. #ifndef __UITERATOR__
  13. #include "UIterator.h"
  14. #endif
  15.  
  16. // Toolbox
  17.  
  18. #ifndef __PACKAGES__
  19. #include <Packages.h>
  20. #endif
  21.  
  22.  
  23. //========================================================================================
  24. // struct CDependencyComparer
  25. //========================================================================================
  26.  
  27. struct CDependencyComparer
  28. {
  29. public:
  30.     Dependency& fTargetDependency;
  31.     TDependencies* fDependencies;
  32.  
  33.     // Constructor
  34.     inline CDependencyComparer(Dependency& targetDependency,
  35.                         TDependencies* theDependencies) :
  36.         fTargetDependency(targetDependency),
  37.         fDependencies(theDependencies)
  38.     { }
  39. };
  40.  
  41.  
  42. //========================================================================================
  43. // GLOBAL Variables
  44. //========================================================================================
  45.  
  46. TDependencySpace* gMacAppDependencies;
  47.  
  48. //========================================================================================
  49. // GLOBAL Procedures
  50. //========================================================================================
  51. static TDependencies* NewDependencies();
  52. static CompareResult CompareDependency(ArrayIndex index,
  53.                                        void* yourDataPtr);
  54.  
  55. #undef Inherited
  56.  
  57. //----------------------------------------------------------------------------------------
  58. // NewDependencies: 
  59. //----------------------------------------------------------------------------------------
  60. #pragma segment DepRes
  61.  
  62. TDependencies* NewDependencies()
  63. {
  64.     TDependencies * dependencies = new TDependencies;
  65.     dependencies->IDependencies();
  66.  
  67.     return dependencies;
  68. }
  69.  
  70.  
  71. //========================================================================================
  72. // CLASS TNotificationQueue
  73. //========================================================================================
  74. #undef Inherited
  75. #define Inherited TDynamicArray
  76.  
  77. #pragma segment MAInit
  78. MA_DEFINE_CLASS_M1(TNotificationQueue,
  79.                    Inherited);
  80.  
  81. //----------------------------------------------------------------------------------------
  82. // TNotificationQueue::NewNotificationQueue: 
  83. //----------------------------------------------------------------------------------------
  84. #pragma segment DepRes
  85.  
  86. TNotificationQueue* TNotificationQueue::NewNotificationQueue()
  87. {
  88.     MAVolatileInit(TNotificationQueue * , it, new TNotificationQueue);
  89.     FailInfo fi;
  90.     Try(fi)
  91.     {
  92.         it->INotificationQueue();
  93.         fi.Success();
  94.     }
  95.     else                                        // Recover
  96.     {
  97.         it->Free();
  98.         fi.ReSignal();
  99.     }
  100.  
  101.     return it;
  102. }
  103.  
  104. //----------------------------------------------------------------------------------------
  105. // TNotificationQueue destructor
  106. //----------------------------------------------------------------------------------------
  107. #pragma segment MADestructorRes
  108.  
  109. TNotificationQueue::~TNotificationQueue()
  110. {
  111. }
  112.  
  113. //----------------------------------------------------------------------------------------
  114. // TNotificationQueue::Dequeue: 
  115. //----------------------------------------------------------------------------------------
  116. #pragma segment DepRes
  117.  
  118. Boolean TNotificationQueue::Dequeue(Notification& item)
  119. {
  120.     Boolean available = (fSize > 0);
  121.     if (available)
  122.     {
  123.         GetElementsAt(1, &item, 1);
  124.         DeleteElementsAt(1, 1);
  125.     }
  126.  
  127.     return available;
  128. }
  129.  
  130. //========================================================================================
  131. // CLASS TDependencies
  132. //========================================================================================
  133. #undef Inherited
  134. #define Inherited TSortedDynamicArray
  135.  
  136. #pragma segment MAInit
  137. MA_DEFINE_CLASS_M1(TDependencies,
  138.                    Inherited);
  139.  
  140. //----------------------------------------------------------------------------------------
  141. // TDependencies destructor
  142. //----------------------------------------------------------------------------------------
  143. #pragma segment MADestructorRes
  144.  
  145. TDependencies::~TDependencies()
  146. {
  147. }
  148.  
  149. //----------------------------------------------------------------------------------------
  150. // TDependencies::AddDependency: 
  151. //----------------------------------------------------------------------------------------
  152. #pragma segment DepRes
  153.  
  154. void TDependencies::AddDependency(TObject* notifier,
  155.                                   TObject* dependent,
  156.                                   DependencyLabels dependencyLabel)
  157. {
  158.     ArrayIndex index;
  159.  
  160.     if (!FindDependency(notifier, dependent, dependencyLabel, index))
  161.         InsertDependencyBefore(index, notifier, dependent, dependencyLabel);
  162. }
  163.  
  164. //----------------------------------------------------------------------------------------
  165. // TDependencies::InsertDependencyBefore: 
  166. //----------------------------------------------------------------------------------------
  167. #pragma segment DepRes
  168.  
  169. void TDependencies::InsertDependencyBefore(ArrayIndex index,
  170.                                            TObject* notifier,
  171.                                            TObject* dependent,
  172.                                            DependencyLabels dependencyLabel)
  173. {
  174.     Dependency newDependency(notifier, dependent, dependencyLabel);
  175.  
  176.     InsertElementsBefore(index, &newDependency, 1);
  177. }
  178.  
  179.  
  180. //----------------------------------------------------------------------------------------
  181. // TDependencies::FindDependency: 
  182. //----------------------------------------------------------------------------------------
  183. #pragma segment DepRes
  184.  
  185. Boolean TDependencies::FindDependency(TObject* notifier,
  186.                                       TObject* dependent,
  187.                                       DependencyLabels dependencyLabel,
  188.                                       ArrayIndex& index)
  189.  
  190.  
  191. {
  192.     Dependency targetDependency(notifier, dependent, dependencyLabel);
  193.     CDependencyComparer aDependencyComparer(targetDependency, this);
  194.  
  195.     return DoSearchElement(&CompareDependency, &aDependencyComparer, index);
  196. }
  197.  
  198. //----------------------------------------------------------------------------------------
  199. // TDependencies::FindPrimaryObject: 
  200. //----------------------------------------------------------------------------------------
  201. #pragma segment DepRes
  202.  
  203. Boolean TDependencies::FindPrimaryObject(TObject* notifier,
  204.                                          ArrayIndex& index)
  205. {
  206.     Dependency targetDependency(notifier, NULL, kNoLabel);
  207.     CDependencyComparer aDependencyComparer(targetDependency, this);
  208.  
  209.     return DoSearchElement(&CompareDependency, &aDependencyComparer, index);
  210. }
  211.  
  212. //----------------------------------------------------------------------------------------
  213. // TDependencies::RemoveDependency: 
  214. //----------------------------------------------------------------------------------------
  215. #pragma segment DepRes
  216.  
  217. void TDependencies::RemoveDependency(TObject* notifier,
  218.                                      TObject* dependent,
  219.                                      DependencyLabels dependencyLabel)
  220. {
  221.     ArrayIndex index;
  222.  
  223.     if (FindDependency(notifier, dependent, dependencyLabel, index))
  224.         DeleteElementsAt(index, 1);
  225. }
  226.  
  227. //----------------------------------------------------------------------------------------
  228. // TDependencies::CompareElements: 
  229. //----------------------------------------------------------------------------------------
  230. #pragma segment DepRes
  231.  
  232. CompareResult TDependencies::CompareElements(void* Element1,
  233.                                              void* Element2)// Override 
  234.  
  235. {
  236.     CompareResult returnVal;
  237.  
  238.     Dependency & Dependency1 = *((DependencyPtr)Element1);
  239.     Dependency & Dependency2 = *((DependencyPtr)Element2);
  240.  
  241.     if (Dependency1.fPrimaryObject > Dependency2.fPrimaryObject)
  242.         returnVal = kItem1GreaterThanItem2;
  243.     else if (Dependency1.fPrimaryObject < Dependency2.fPrimaryObject)
  244.         returnVal = kItem1LessThanItem2;
  245.     else
  246.     {
  247.         if ((Dependency1.fSecondaryObject == NULL) || (Dependency2.fSecondaryObject == NULL) || (Dependency1.fSecondaryObject == Dependency2.fSecondaryObject))
  248.             returnVal = kItem1EqualItem2;
  249.         else if (Dependency1.fSecondaryObject < Dependency2.fSecondaryObject)
  250.             returnVal = kItem1LessThanItem2;
  251.         else
  252.             returnVal = kItem1GreaterThanItem2;
  253.     }
  254.  
  255.     return returnVal;
  256. }
  257.  
  258.  
  259. //========================================================================================
  260. // CLASS TDependencySpace
  261. //========================================================================================
  262. #undef Inherited
  263. #define Inherited TObject
  264.  
  265. #pragma segment MAInit
  266. MA_DEFINE_CLASS_M1(TDependencySpace,
  267.                    Inherited);
  268.  
  269. //----------------------------------------------------------------------------------------
  270. // TDependencySpace destructor
  271. //----------------------------------------------------------------------------------------
  272. #pragma segment MADestructorRes
  273.  
  274. TDependencySpace::~TDependencySpace()
  275. {
  276. }
  277.  
  278. //----------------------------------------------------------------------------------------
  279. // TDependencySpace::AddDependency: 
  280. //----------------------------------------------------------------------------------------
  281. #pragma segment DepRes
  282.  
  283. void TDependencySpace::AddDependency(TObject*    /*notifier*/ ,
  284.                                      TObject*    /*dependent*/ ,
  285.                                      DependencyLabels/*dependencyLabel*/ )
  286. {
  287.     SubClassResponsibility();
  288. }
  289.  
  290. //----------------------------------------------------------------------------------------
  291. // TDependencySpace::RemoveDependency: 
  292. //----------------------------------------------------------------------------------------
  293. #pragma segment DepRes
  294.  
  295. void TDependencySpace::RemoveDependency(TObject*/*notifier*/  ,
  296.                                         TObject*/*dependent*/  ,
  297.                                         DependencyLabels/*dependencyLabel*/ )
  298. {
  299.     SubClassResponsibility();
  300. }
  301.  
  302. //----------------------------------------------------------------------------------------
  303. // TDependencySpace::NotifierChanged: 
  304. //----------------------------------------------------------------------------------------
  305. #pragma segment DepRes
  306.  
  307. void TDependencySpace::NotifierChanged(TObject*    /*notifier*/ ,
  308.                                        ChangeID    /*theChange*/,
  309.                                        TObject*    /*changedBy*/ )// Override
  310. {
  311.     SubClassResponsibility();
  312. }
  313.  
  314. //----------------------------------------------------------------------------------------
  315. // TDependencySpace::RemoveDependencies: 
  316. //----------------------------------------------------------------------------------------
  317. #pragma segment DepRes
  318.  
  319. void TDependencySpace::RemoveDependencies(TObject*/*anObject*/  )
  320. {
  321.     SubClassResponsibility();
  322. }
  323.  
  324.  
  325. //========================================================================================
  326. // CLASS TSimpleDependencySpace
  327. //========================================================================================
  328. #undef Inherited
  329. #define Inherited TDependencySpace
  330.  
  331. #pragma segment MAInit
  332. MA_DEFINE_CLASS_M1(TSimpleDependencySpace,
  333.                    Inherited);
  334.  
  335. //----------------------------------------------------------------------------------------
  336. // TSimpleDependencySpace constructor
  337. //----------------------------------------------------------------------------------------
  338. #pragma segment DepRes
  339.  
  340. TSimpleDependencySpace::TSimpleDependencySpace() :
  341.     fDependents(NULL),
  342.     fNotifiers(NULL)
  343. {
  344. }
  345. // TSimpleDependencySpace::TSimpleDependencySpace
  346.  
  347. //----------------------------------------------------------------------------------------
  348. // TSimpleDependencySpace::Free: 
  349. //----------------------------------------------------------------------------------------
  350. #pragma segment DepRes
  351.  
  352. TSimpleDependencySpace::~TSimpleDependencySpace()
  353.  
  354. {
  355.     fDependents = (TDependencies *)FreeIfObject(fDependents);
  356.     fNotifiers = (TDependencies *)FreeIfObject(fNotifiers);
  357. }
  358.  
  359. //----------------------------------------------------------------------------------------
  360. // TSimpleDependencySpace::AddDependency: 
  361. //----------------------------------------------------------------------------------------
  362. #pragma segment DepRes
  363.  
  364. void TSimpleDependencySpace::AddDependency(TObject* notifier,
  365.                                            TObject* dependent,
  366.                                            DependencyLabels dependencyLabel)// Override
  367. {
  368.     if (fDependents == NULL)
  369.         fDependents = NewDependencies();
  370.     if (fNotifiers == NULL)
  371.         fNotifiers = NewDependencies();
  372.     fDependents->AddDependency(notifier, dependent, dependencyLabel);
  373.     fNotifiers->AddDependency(dependent, notifier, dependencyLabel);
  374. }
  375.  
  376. //----------------------------------------------------------------------------------------
  377. // TSimpleDependencySpace::RemoveDependency: 
  378. //----------------------------------------------------------------------------------------
  379. #pragma segment DepRes
  380.  
  381. void TSimpleDependencySpace::RemoveDependency(TObject* notifier,
  382.                                               TObject* dependent,
  383.                                               DependencyLabels dependencyLabel)// Override
  384. {
  385.     if (fDependents)
  386.         fDependents->RemoveDependency(notifier, dependent, dependencyLabel);
  387.     if (fNotifiers)
  388.         fNotifiers->RemoveDependency(dependent, notifier, dependencyLabel);
  389. }
  390.  
  391. //----------------------------------------------------------------------------------------
  392. // TSimpleDependencySpace::NotifierChanged: 
  393. //----------------------------------------------------------------------------------------
  394. #pragma segment DepRes
  395.  
  396. void TSimpleDependencySpace::NotifierChanged(TObject* notifier,
  397.                                              ChangeID theChange,
  398.                                              TObject* changedBy)// Override
  399. {
  400.     CDependentIterator iter(notifier, this);
  401.  
  402.     for (TObject * dependent = iter.FirstDependent(); iter.More(); dependent = iter.NextDependent())
  403.         dependent->DoUpdate(theChange, notifier, changedBy, this);
  404. }
  405.  
  406. //----------------------------------------------------------------------------------------
  407. // TSimpleDependencySpace::RemoveDependencies: 
  408. //----------------------------------------------------------------------------------------
  409. #pragma segment DepRes
  410.  
  411. void TSimpleDependencySpace::RemoveDependencies(TObject* anObject)// Override
  412. {
  413.     {
  414.         CDependentIterator iter(anObject, this);
  415.  
  416.         for (TObject * dependent = iter.FirstDependent(); iter.More(); dependent = iter.NextDependent())
  417.         {
  418.             fDependents->DeleteElementsAt(iter.fCurrentIndex, 1);
  419.             fNotifiers->RemoveDependency(dependent, anObject, kNoLabel);
  420.         }
  421.     }
  422.     {
  423.         CNotifierIterator iter(anObject, this);
  424.  
  425.         for (TObject * notifier = iter.FirstNotifier(); iter.More(); notifier = iter.NextNotifier())
  426.         {
  427.             fNotifiers->DeleteElementsAt(iter.fCurrentIndex, 1);
  428.             fDependents->RemoveDependency(notifier, anObject, kNoLabel);
  429.         }
  430.     }
  431. }
  432.  
  433. //========================================================================================
  434. // CLASS TStandardDependencySpace
  435. //========================================================================================
  436. #undef Inherited
  437. #define Inherited TSimpleDependencySpace
  438.  
  439. #pragma segment MAInit
  440. MA_DEFINE_CLASS_M1(TStandardDependencySpace,
  441.                    Inherited);
  442.  
  443. //----------------------------------------------------------------------------------------
  444. // TStandardDependencySpace constructor
  445. //----------------------------------------------------------------------------------------
  446. #pragma segment DepRes
  447.  
  448. TStandardDependencySpace::TStandardDependencySpace() :
  449.     fNestedUpdates(NULL),
  450.     fUpdating(FALSE)
  451. {
  452. }
  453. // TStandardDependencySpace::TStandardDependencySpace
  454.  
  455. //----------------------------------------------------------------------------------------
  456. // TStandardDependencySpace destructor
  457. //----------------------------------------------------------------------------------------
  458. #pragma segment MADestructorRes
  459.  
  460. TStandardDependencySpace::~TStandardDependencySpace()
  461. {
  462.     fNestedUpdates = (TNotificationQueue *)FreeIfObject(fNestedUpdates);
  463. }
  464.  
  465. //----------------------------------------------------------------------------------------
  466. // TStandardDependencySpace::NotifierChanged: 
  467. //----------------------------------------------------------------------------------------
  468. #pragma segment DepRes
  469.  
  470. void TStandardDependencySpace::NotifierChanged(TObject* notifier,
  471.                                                ChangeID theChange,
  472.                                                TObject* changedBy)// Override
  473. {
  474.     if (fUpdating)
  475.     {
  476.         if (!fNestedUpdates)
  477.             fNestedUpdates = TNotificationQueue::NewNotificationQueue();
  478.  
  479.         fNestedUpdates->Queue(Notification(notifier, theChange, changedBy));
  480.     }
  481.     else
  482.     {
  483.         NotifyDependents(notifier, theChange, changedBy);
  484.  
  485.         if (fNestedUpdates)
  486.         {
  487.             while (fNestedUpdates->GetSize() > 0)
  488.             {
  489.                 Notification n;
  490.                 if (fNestedUpdates->Dequeue(n))
  491.                     NotifyDependents(n.fNotifier, n.fChange, n.fChangedBy);
  492.             }
  493.         }
  494.     }
  495. }
  496.  
  497. //----------------------------------------------------------------------------------------
  498. // TStandardDependencySpace::NotifyDependents: 
  499. //----------------------------------------------------------------------------------------
  500. #pragma segment DepRes
  501.  
  502. void TStandardDependencySpace::NotifyDependents(TObject* notifier,
  503.                                                 ChangeID theChange,
  504.                                                 TObject* changedBy)
  505. {
  506.     if (notifier && (theChange != kNoChange))
  507.     {
  508.         fUpdating = TRUE;
  509.         MarkAllDependents(notifier, TRUE);
  510.         UpdateMarkedObjects(theChange, notifier, changedBy);
  511.         fUpdating = FALSE;
  512.     }
  513. }
  514.  
  515. //----------------------------------------------------------------------------------------
  516. // TStandardDependencySpace::MarkObject: 
  517. //----------------------------------------------------------------------------------------
  518. #pragma segment DepRes
  519. void TStandardDependencySpace::MarkObject(TObject* anObject,
  520.                                           Boolean state)
  521. {
  522.     ArrayIndex index;
  523.     DependencyPtr p;
  524.  
  525.     if (anObject)
  526.     {
  527.         if ((fNotifiers) && fNotifiers->FindPrimaryObject(anObject, index))
  528.         {
  529.             p = (DependencyPtr)fNotifiers->ComputeAddress(index);
  530.             if ((state) != (p->fLabel < 0))
  531.                 p->fLabel = -(p->fLabel);
  532.         }
  533.     }
  534. }
  535.  
  536. //----------------------------------------------------------------------------------------
  537. // TStandardDependencySpace::IsObjectMarked: 
  538. //----------------------------------------------------------------------------------------
  539. #pragma segment DepRes
  540. Boolean TStandardDependencySpace::IsObjectMarked(TObject* anObject)
  541. {
  542.     Boolean returnVal = FALSE;
  543.  
  544.     ArrayIndex index;
  545.  
  546.     if (anObject && fNotifiers && fNotifiers->FindPrimaryObject(anObject, index))
  547.         returnVal = (((DependencyPtr)fNotifiers->ComputeAddress(index))->fLabel < 0);
  548.  
  549.     return returnVal;
  550. }
  551.  
  552. //----------------------------------------------------------------------------------------
  553. // TStandardDependencySpace::MarkAllDependents: 
  554. //----------------------------------------------------------------------------------------
  555. #pragma segment DepRes
  556. void TStandardDependencySpace::MarkAllDependents(TObject* notifier,
  557.                                                  Boolean state)
  558. {
  559.     if (notifier)
  560.     {
  561.         CDependentIterator iter(notifier, this);
  562.  
  563.         for (TObject * dependent = iter.FirstDependent(); iter.More(); dependent = iter.NextDependent())
  564.         {
  565.             if (state != IsObjectMarked(dependent))
  566.             {
  567.                 MarkObject(dependent, state);
  568.                 MarkAllDependents(dependent, state);
  569.             }
  570.         }
  571.     }
  572. }
  573.  
  574. //----------------------------------------------------------------------------------------
  575. // TStandardDependencySpace::UpdateMarkedObjects: 
  576. //----------------------------------------------------------------------------------------
  577. #pragma segment DepRes
  578.  
  579. void TStandardDependencySpace::UpdateMarkedObjects(ChangeID theChange,
  580.                                                    TObject* changedObject,
  581.                                                    TObject* changedBy)
  582. {
  583.     DependencyPtr p;
  584.     {
  585.         CArrayIterator iter(fNotifiers);
  586.  
  587.         for (ArrayIndex index = iter.FirstIndex(); iter.More(); index = iter.NextIndex())
  588.         {
  589.             p = (DependencyPtr)fNotifiers->ComputeAddress(index);
  590.             if (p->fLabel < 0)
  591.                 HandleUpdate(p->fPrimaryObject, theChange, changedObject, changedBy);
  592.         }
  593.     }
  594. }
  595.  
  596. //----------------------------------------------------------------------------------------
  597. // TStandardDependencySpace::HandleUpdate: 
  598. //----------------------------------------------------------------------------------------
  599. #pragma segment DepRes
  600.  
  601. void TStandardDependencySpace::HandleUpdate(TObject* anObject,
  602.                                             ChangeID theChange,
  603.                                             TObject* changedObject,
  604.                                             TObject* changedBy)
  605. {
  606.     if (IsObjectMarked(anObject))
  607.     {
  608.         MarkObject(anObject, FALSE);
  609.  
  610.         // ••• This should be changed to iterate rather than recurse
  611.         UpdateNotifiers(anObject, theChange, changedObject, changedBy);
  612.  
  613.         anObject->DoUpdate(theChange, changedObject, changedBy, this);
  614.     }
  615. }
  616.  
  617. //----------------------------------------------------------------------------------------
  618. // TStandardDependencySpace::UpdateNotifiers: 
  619. //----------------------------------------------------------------------------------------
  620. #pragma segment MAObjectRes
  621.  
  622. void TStandardDependencySpace::UpdateNotifiers(TObject* anObject,
  623.                                                ChangeID theChange,
  624.                                                TObject* changedObject,
  625.                                                TObject* changedBy)
  626. {
  627.     CNotifierIterator iter(anObject, this);
  628.  
  629.     for (TObject * notifier = iter.FirstNotifier(); iter.More(); notifier = iter.NextNotifier())
  630.         HandleUpdate(notifier, theChange, changedObject, changedBy);
  631. }
  632.  
  633.  
  634. //----------------------------------------------------------------------------------------
  635. // CompareDependency: 
  636. //----------------------------------------------------------------------------------------
  637. #pragma segment DepRes
  638.  
  639. CompareResult CompareDependency(ArrayIndex index,
  640.                                 void* yourDataPtr)
  641. {
  642.     CDependencyComparer * dependencyInfo = (CDependencyComparer *)yourDataPtr;
  643.  
  644.     return dependencyInfo->fDependencies->CompareElements(&dependencyInfo->fTargetDependency, dependencyInfo->fDependencies->ComputeAddress(index));
  645. }
  646.  
  647.  
  648. //========================================================================================
  649. // CLASS CDependencyIterator
  650. //========================================================================================
  651. #undef Inherited
  652. #define Inherited CArrayIterator
  653.  
  654. //----------------------------------------------------------------------------------------
  655. // CDependencyIterator::CDependencyIterator: CDependentIterator
  656. //----------------------------------------------------------------------------------------
  657. #pragma segment DepRes
  658.  
  659. CDependencyIterator::CDependencyIterator(TDependencies* theArray,
  660.                                          TObject* theObject) :
  661.     CArrayIterator(theArray, kIterateForward)
  662. {
  663.     fObject = theObject;
  664. }
  665. // CDependencyIterator::CDependencyIterator 
  666.  
  667. //----------------------------------------------------------------------------------------
  668. // CDependencyIterator::~CDependencyIterator: 
  669. //----------------------------------------------------------------------------------------
  670. #pragma segment DepRes
  671.  
  672. CDependencyIterator::~CDependencyIterator()
  673. {
  674. }
  675.  
  676. //----------------------------------------------------------------------------------------
  677. // CDependencyIterator::Reset: 
  678. //----------------------------------------------------------------------------------------
  679. #pragma segment DepRes
  680.  
  681. void CDependencyIterator::Reset()                // Override
  682. {
  683.     if (fDynamicArray)
  684.     {
  685.         ArrayIndex foundIndex;
  686.  
  687.         // Although the lists are ordered the search is a binary search and can return
  688.         // a random entry from the set of matching entries.  First back up the the _real_
  689.         // first matching entry and then we will march forward applying the DoToDependency
  690.  
  691.         if (((TDependencies *)(fDynamicArray))->FindPrimaryObject(fObject, foundIndex))
  692.         {
  693.             {                                    // extra block to ensure iterators are destroyed in fifo order
  694.                 CArrayIterator iter(fDynamicArray, 1, foundIndex, kIterateBackward);
  695.                 for (ArrayIndex i = iter.FirstIndex(); iter.More(); i = iter.NextIndex())
  696.                 {
  697.                     if (((TDependencies *)(fDynamicArray))->PrimaryObjectAt(i) == fObject)
  698.                         foundIndex = i;
  699.                     else
  700.                         break;
  701.                 }
  702.                 fLowBound = foundIndex;
  703.             }
  704.         }
  705.         else
  706.             fLowBound = kEmptyIndex;
  707.     }
  708.  
  709.     CArrayIterator::Reset();
  710. }
  711.  
  712. //----------------------------------------------------------------------------------------
  713. // CDependencyIterator::More: 
  714. //----------------------------------------------------------------------------------------
  715. #pragma segment DepRes
  716.  
  717. Boolean CDependencyIterator::More()                // Override
  718. {
  719.     //    return CArrayIterator::More() && (CurrentObject() == fObject);
  720.  
  721.     return CArrayIterator::More() && (((TDependencies *)fDynamicArray)->PrimaryObjectAt(CurrentIndex()) == fObject);
  722. }
  723.  
  724. //----------------------------------------------------------------------------------------
  725. // CDependencyIterator::CurrentObject: 
  726. //----------------------------------------------------------------------------------------
  727. #pragma segment DepRes
  728.  
  729. TObject* CDependencyIterator::CurrentObject()
  730. {
  731.     return ((TDependencies *)fDynamicArray)->SecondaryObjectAt(CurrentIndex());
  732. }
  733.  
  734. //----------------------------------------------------------------------------------------
  735. // CDependencyIterator::FirstObject: 
  736. //----------------------------------------------------------------------------------------
  737. #pragma segment DepRes
  738.  
  739. TObject* CDependencyIterator::FirstObject()
  740. {
  741.     Reset();
  742.  
  743.     return More() ? ((TDependencies *)fDynamicArray)->SecondaryObjectAt(FirstIndex()) : NULL;
  744. }
  745.  
  746. //----------------------------------------------------------------------------------------
  747. // CDependencyIterator::NextObject: 
  748. //----------------------------------------------------------------------------------------
  749. #pragma segment DepRes
  750.  
  751. TObject* CDependencyIterator::NextObject()
  752. {
  753.     return ((TDependencies *)fDynamicArray)->SecondaryObjectAt(NextIndex());
  754. }
  755.  
  756.  
  757. //========================================================================================
  758. // CLASS CDependentIterator
  759. //========================================================================================
  760. #undef Inherited
  761. #define Inherited CDependencyIterator
  762.  
  763. //----------------------------------------------------------------------------------------
  764. // CDependentIterator::CDependentIterator: 
  765. //----------------------------------------------------------------------------------------
  766. #pragma segment DepRes
  767.  
  768. CDependentIterator::CDependentIterator(TObject* theObject,
  769.                                        TSimpleDependencySpace* dependencySpace) :
  770.     CDependencyIterator(dependencySpace ? dependencySpace->fDependents : NULL, theObject)
  771. {
  772. }
  773.  
  774. //----------------------------------------------------------------------------------------
  775. // CDependentIterator::~CDependentIterator: 
  776. //----------------------------------------------------------------------------------------
  777. #pragma segment DepRes
  778.  
  779. CDependentIterator::~CDependentIterator()
  780. {
  781. }
  782.  
  783.  
  784. //========================================================================================
  785. // CLASS CNotifierIterator
  786. //========================================================================================
  787. #undef Inherited
  788. #define Inherited CDependencyIterator
  789.  
  790. //----------------------------------------------------------------------------------------
  791. // CNotifierIterator::CNotifierIterator: 
  792. //----------------------------------------------------------------------------------------
  793. #pragma segment DepRes
  794.  
  795. CNotifierIterator::CNotifierIterator(TObject* theObject,
  796.                                      TSimpleDependencySpace* dependencySpace) :
  797.     CDependencyIterator(dependencySpace ? dependencySpace->fNotifiers : NULL, theObject)
  798. {
  799. }
  800.  
  801. //----------------------------------------------------------------------------------------
  802. // CNotifierIterator::~CNotifierIterator: 
  803. //----------------------------------------------------------------------------------------
  804. #pragma segment DepRes
  805.  
  806. CNotifierIterator::~CNotifierIterator()
  807. {
  808. }
  809.  
  810. //----------------------------------------------------------------------------------------
  811. // End of UDependencies.cp
  812.  
  813. #pragma segment Inline
  814.  
  815.